﻿using System;
using SWGeneracionE.Models;

namespace SWGeneracionE.Models.Repositories
{

    public class UnitOfWork : IDisposable
    {

        private GEEntities context = new GEEntities();
        private GenericRepository<GEEntities, Actividad> actividadR;
        private GenericRepository<GEEntities, AsignacionGrupo> asignacionGrupoR;
        private GenericRepository<GEEntities, Bitacora> bitacoraR;
        private GenericRepository<GEEntities, DocumentoXParticipante> documentoXParticipanteR;
        private GenericRepository<GEEntities, Evento> eventoR;
        private GenericRepository<GEEntities, Grupo> grupoR;
        private GenericRepository<GEEntities, Iglesia> iglesiaR;
        private GenericRepository<GEEntities, IngresoRecaudacion> ingresoRecaudacionR;
        private GenericRepository<GEEntities, Lugar> lugarR;
        private GenericRepository<GEEntities, Movimiento> movimientoR;
        private GenericRepository<GEEntities, Notificacion> notificacionR;
        private GenericRepository<GEEntities, Pago> pagoR;
        private GenericRepository<GEEntities, Pais> paisR;
        private GenericRepository<GEEntities, Parametro> parametroR;
        private GenericRepository<GEEntities, Participante> participanteR;
        private ParticipanteXEventoRepository participanteXEventoR;
        private GenericRepository<GEEntities, Recaudacion> recaudacionR;
        private GenericRepository<GEEntities, Servicio> servicioR;
        private GenericRepository<GEEntities, TipoDocumentoID> tipoDocumentoIdR;
        private GenericRepository<GEEntities, Transferencia> transferenciaR;
        private GenericRepository<GEEntities, Bus> busR;
        private GenericRepository<GEEntities, BusParticipante> busParticipanteR;
        private webpages_MenuRepository webpages_MenuR;
        private MemoryRepository<EstadoCivil> estadoCivilR;
        private MemoryRepository<Sexo> sexoR;
        private MemoryRepository<TipoTransporte> tipoTransporteR;
        private GenericRepository<GEEntities, webpages_MenuRol> webpages_MenuRolR;
        private MemoryRepository<EstadoMovimiento> estadoMovimientoR;
        private MemoryRepository<TipoMovimiento> tipoMovimientoR;
        private MemoryRepository<TipoPago> tipoPagoR;
        private MemoryRepository<EstadoParticipante> estadoParticipanteR;
        private MemoryRepository<EstadoBus> estadoBusR;

        public GenericRepository<GEEntities, Actividad> actividadRepository
        {
            get
            {
                if (this.actividadR == null)
                    this.actividadR = new GenericRepository<GEEntities, Actividad>(context);
                return actividadR;
            }
        }

        public GenericRepository<GEEntities, AsignacionGrupo> asignacionGrupoRepository
        {
            get
            {
                if (this.asignacionGrupoR == null)
                    this.asignacionGrupoR = new GenericRepository<GEEntities, AsignacionGrupo>(context);
                return asignacionGrupoR;
            }
        }

        public GenericRepository<GEEntities, Bitacora> bitacoraRepository
        {
            get
            {
                if (this.bitacoraR == null)
                    this.bitacoraR = new GenericRepository<GEEntities, Bitacora>(context);
                return bitacoraR;
            }
        }

        public GenericRepository<GEEntities, DocumentoXParticipante> documentoXParticipanteRepository
        {
            get
            {
                if (this.documentoXParticipanteR == null)
                    this.documentoXParticipanteR = new GenericRepository<GEEntities, DocumentoXParticipante>(context);
                return documentoXParticipanteR;
            }
        }

        public GenericRepository<GEEntities, Evento> eventoRepository
        {
            get
            {
                if (this.eventoR == null)
                    this.eventoR = new GenericRepository<GEEntities, Evento>(context);
                return eventoR;
            }
        }

        public GenericRepository<GEEntities, Grupo> grupoRepository
        {
            get
            {
                if (this.grupoR == null)
                    this.grupoR = new GenericRepository<GEEntities, Grupo>(context);
                return grupoR;
            }
        }

        public GenericRepository<GEEntities, Iglesia> iglesiaRepository
        {
            get
            {
                if (this.iglesiaR == null)
                    this.iglesiaR = new GenericRepository<GEEntities, Iglesia>(context);
                return iglesiaR;
            }
        }

        public GenericRepository<GEEntities, IngresoRecaudacion> ingresoRecaudacionRepository
        {
            get
            {
                if (this.ingresoRecaudacionR == null)
                    this.ingresoRecaudacionR = new GenericRepository<GEEntities, IngresoRecaudacion>(context);
                return ingresoRecaudacionR;
            }
        }

        public GenericRepository<GEEntities, Lugar> lugarRepository
        {
            get
            {
                if (this.lugarR == null)
                    this.lugarR = new GenericRepository<GEEntities, Lugar>(context);
                return lugarR;
            }
        }

        public GenericRepository<GEEntities, Movimiento> movimientoRepository
        {
            get
            {
                if (this.movimientoR == null)
                    this.movimientoR = new GenericRepository<GEEntities, Movimiento>(context);
                return movimientoR;
            }
        }

        public GenericRepository<GEEntities, Notificacion> notificacionRepository
        {
            get
            {
                if (this.notificacionR == null)
                    this.notificacionR = new GenericRepository<GEEntities, Notificacion>(context);
                return notificacionR;
            }
        }

        public GenericRepository<GEEntities, Pago> pagoRepository
        {
            get
            {
                if (this.pagoR == null)
                    this.pagoR = new GenericRepository<GEEntities, Pago>(context);
                return pagoR;
            }
        }

        public GenericRepository<GEEntities, Pais> paisRepository
        {
            get
            {
                if (this.paisR == null)
                    this.paisR = new GenericRepository<GEEntities, Pais>(context);
                return paisR;
            }
        }

        public GenericRepository<GEEntities, Parametro> parametroRepository
        {
            get
            {
                if (this.parametroR == null)
                    this.parametroR = new GenericRepository<GEEntities, Parametro>(context);
                return parametroR;
            }
        }

        public GenericRepository<GEEntities, Participante> participanteRepository
        {
            get
            {
                if (this.participanteR == null)
                    this.participanteR = new GenericRepository<GEEntities, Participante>(context);
                return participanteR;
            }
        }

        public ParticipanteXEventoRepository participanteXEventoRepository
        {
            get
            {
                if (this.participanteXEventoR == null)
                    this.participanteXEventoR = new ParticipanteXEventoRepository(context);
                return participanteXEventoR;
            }
        }

        public GenericRepository<GEEntities, Recaudacion> recaudacionRepository
        {
            get
            {
                if (this.recaudacionR == null)
                    this.recaudacionR = new GenericRepository<GEEntities, Recaudacion>(context);
                return recaudacionR;
            }
        }

        public GenericRepository<GEEntities, Servicio> servicioRepository
        {
            get
            {
                if (this.servicioR == null)
                    this.servicioR = new GenericRepository<GEEntities, Servicio>(context);
                return servicioR;
            }
        }

        public GenericRepository<GEEntities, TipoDocumentoID> tipoDocumentoIdRepository
        {
            get
            {
                if (this.tipoDocumentoIdR == null)
                    this.tipoDocumentoIdR = new GenericRepository<GEEntities, TipoDocumentoID>(context);
                return tipoDocumentoIdR;
            }
        }

        public GenericRepository<GEEntities, Transferencia> transferenciaRepository
        {
            get
            {
                if (this.transferenciaR == null)
                    this.transferenciaR = new GenericRepository<GEEntities, Transferencia>(context);
                return transferenciaR;
            }
        }

        public webpages_MenuRepository webpages_MenuRepository
        {
            get
            {
                if (this.webpages_MenuR == null)
                    this.webpages_MenuR = new webpages_MenuRepository(context);
                return webpages_MenuR;
            }
        }

        public GenericRepository<GEEntities, Bus> busRepository
        {
            get
            {
                if (this.busR == null)
                    this.busR = new GenericRepository<GEEntities, Bus>(context);
                return busR;
            }
        }

        public GenericRepository<GEEntities, BusParticipante> busParticipanteRepository
        {
            get
            {
                if (this.busParticipanteR == null)
                    this.busParticipanteR = new GenericRepository<GEEntities, BusParticipante>(context);
                return busParticipanteR;
            }
        }

        public GenericRepository<GEEntities, webpages_MenuRol> webpages_MenuRolRepository
        {
            get
            {
                if (this.webpages_MenuRolR == null)
                    this.webpages_MenuRolR = new GenericRepository<GEEntities, webpages_MenuRol>(context);
                return webpages_MenuRolR;
            }
        }

        public MemoryRepository<EstadoCivil> estadoCivilRepository
        {
            get
            {
                if (this.estadoCivilR == null)
                {
                    this.estadoCivilR = new MemoryRepository<EstadoCivil>();
                    estadoCivilR.Add(new EstadoCivil(SWGeneracionE.Constantes.ESTADOCIVIL_SOLTERO, SWGeneracionE.Constantes.STR_ESTADOCIVIL_SOLTERO));
                    estadoCivilR.Add(new EstadoCivil(SWGeneracionE.Constantes.ESTADOCIVIL_CASADO, SWGeneracionE.Constantes.STR_ESTADOCIVIL_CASADO));
                }
                return estadoCivilR;
            }
        }

        public MemoryRepository<Sexo> sexoRepository
        {
            get
            {
                if (this.sexoR == null)
                {
                    this.sexoR = new MemoryRepository<Sexo>();
                    sexoR.Add(new Sexo(SWGeneracionE.Constantes.SEXO_FEMENINO, SWGeneracionE.Constantes.SEXO_FEMENINO));
                    sexoR.Add(new Sexo(SWGeneracionE.Constantes.SEXO_MASCULINO, SWGeneracionE.Constantes.SEXO_MASCULINO));
                }
                return sexoR;
            }
        }

        public MemoryRepository<TipoTransporte> tipoTransporteRepository
        {
            get
            {
                if (this.tipoTransporteR == null)
                {
                    this.tipoTransporteR = new MemoryRepository<TipoTransporte>();
                    tipoTransporteR.Add(new TipoTransporte(SWGeneracionE.Constantes.TIPOTRANSPORTE_BUS.ToString(), SWGeneracionE.Constantes.STR_TIPOTRANSPORTE_BUS));
                    tipoTransporteR.Add(new TipoTransporte(SWGeneracionE.Constantes.TIPOTRANSPORTE_AUTO.ToString(), SWGeneracionE.Constantes.STR_TIPOTRANSPORTE_AUTO));
                }
                return tipoTransporteR;
            }
        }

        public MemoryRepository<EstadoMovimiento> estadoMovimientoRepository
        {
            get
            {
                if (this.estadoMovimientoR == null)
                {
                    this.estadoMovimientoR = new MemoryRepository<EstadoMovimiento>();
                    estadoMovimientoR.Add(new EstadoMovimiento(SWGeneracionE.Constantes.ESTADOMOVIMIENTO_INGRESADO, SWGeneracionE.Constantes.STR_ESTADOMOVIMIENTO_INGRESADO));
                    estadoMovimientoR.Add(new EstadoMovimiento(SWGeneracionE.Constantes.ESTADOMOVIMIENTO_AUTORIZADO, SWGeneracionE.Constantes.STR_ESTADOMOVIMIENTO_AUTORIZADO));
                    estadoMovimientoR.Add(new EstadoMovimiento(SWGeneracionE.Constantes.ESTADOMOVIMIENTO_RECHAZADO, SWGeneracionE.Constantes.STR_ESTADOMOVIMIENTO_RECHAZADO));
                }
                return estadoMovimientoR;
            }
        }

        public MemoryRepository<TipoMovimiento> tipoMovimientoRepository
        {
            get
            {
                if (this.tipoMovimientoR == null)
                {
                    this.tipoMovimientoR = new MemoryRepository<TipoMovimiento>();
                    tipoMovimientoR.Add(new TipoMovimiento(SWGeneracionE.Constantes.TIPOMOVIMIENTO_DEPOSITOBANCARIO, SWGeneracionE.Constantes.STR_TIPOMOVIMIENTO_DEPOSITOBANCARIO));
                    tipoMovimientoR.Add(new TipoMovimiento(SWGeneracionE.Constantes.TIPOMOVIMIENTO_PAGOHOTEL, SWGeneracionE.Constantes.STR_TIPOMOVIMIENTO_PAGOHOTEL));
                    tipoMovimientoR.Add(new TipoMovimiento(SWGeneracionE.Constantes.TIPOMOVIMIENTO_TRANSFERENCIABANCARIA, SWGeneracionE.Constantes.STR_TIPOMOVIMIENTO_TRANSFERENCIABANCARIA));
                }
                return tipoMovimientoR;
            }
        }

        public MemoryRepository<TipoPago> tipoPagoRepository
        {
            get
            {
                if (this.tipoPagoR == null)
                {
                    this.tipoPagoR = new MemoryRepository<TipoPago>();
                    tipoPagoR.Add(new TipoPago(SWGeneracionE.Constantes.TIPOPAGO_CHEQUE, SWGeneracionE.Constantes.STR_TIPOPAGO_CHEQUE, SWGeneracionE.Constantes.TIPOMOVIMIENTO_DEPOSITOBANCARIO));
                    tipoPagoR.Add(new TipoPago(SWGeneracionE.Constantes.TIPOPAGO_DEPOSITOBANCARIO, SWGeneracionE.Constantes.STR_TIPOPAGO_DEPOSITOBANCARIO, SWGeneracionE.Constantes.TIPOMOVIMIENTO_DEPOSITOBANCARIO));
                    tipoPagoR.Add(new TipoPago(SWGeneracionE.Constantes.TIPOPAGO_EFECTIVO, SWGeneracionE.Constantes.STR_TIPOPAGO_EFECTIVO, SWGeneracionE.Constantes.TIPOMOVIMIENTO_DEPOSITOBANCARIO));
                    tipoPagoR.Add(new TipoPago(SWGeneracionE.Constantes.TIPOPAGO_PAGOHOTEL, SWGeneracionE.Constantes.STR_TIPOPAGO_PAGOHOTEL, SWGeneracionE.Constantes.TIPOMOVIMIENTO_PAGOHOTEL));
                    tipoPagoR.Add(new TipoPago(SWGeneracionE.Constantes.TIPOPAGO_TRANSFERENCIABANCARIA, SWGeneracionE.Constantes.STR_TIPOPAGO_TRANSFERENCIABANCARIA, SWGeneracionE.Constantes.TIPOMOVIMIENTO_TRANSFERENCIABANCARIA));
                }
                return tipoPagoR;
            }
        }

        public MemoryRepository<EstadoParticipante> estadoParticipanteRepository
        {
            get
            {
                if (this.estadoParticipanteR == null)
                {
                    this.estadoParticipanteR = new MemoryRepository<EstadoParticipante>();
                    estadoParticipanteR.Add(new EstadoParticipante(SWGeneracionE.Constantes.ESTADORECAUDACION_INGRESADO, SWGeneracionE.Constantes.STR_ESTADOPARTICIPANTE_INGRESADO));
                    estadoParticipanteR.Add(new EstadoParticipante(SWGeneracionE.Constantes.ESTADOPARTICIPANTE_INSCRITO, SWGeneracionE.Constantes.STR_ESTADOPARTICIPANTE_INSCRITO));
                    estadoParticipanteR.Add(new EstadoParticipante(SWGeneracionE.Constantes.ESTADOPARTICIPANTE_CANCELADO, SWGeneracionE.Constantes.STR_ESTADOPARTICIPANTE_CANCELADO));
                }
                return estadoParticipanteR;
            }
        }

        public MemoryRepository<EstadoBus> estadoBusRepository
        {
            get
            {
                if (this.estadoBusR == null)
                {
                    this.estadoBusR = new MemoryRepository<EstadoBus>();
                    estadoBusR.Add(new EstadoBus(SWGeneracionE.Constantes.ESTADOBUS_ABIERTO, SWGeneracionE.Constantes.STR_ESTADOBUS_ABIERTO));
                    estadoBusR.Add(new EstadoBus(SWGeneracionE.Constantes.ESTADOBUS_CERRADO, SWGeneracionE.Constantes.STR_ESTADOBUS_CERRADO));
                }
                return estadoBusR;
            }
        }

        public void Save()
        {
            context.SaveChanges();
        }


        private bool disposed = false;
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                    context.Dispose();
            }

            this.disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

    }

}